SherbyNet - /page/wikibook/entry.mu

Micron Document

Operators in C and C++

32.3 KB · ⇊ 15 parts · ⤓ Micron 32.3 KB · ⤓ HTML 157.8 KB

──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────

top

This is a list of operators in the C and C++ programming languages.

All listed operators are in C++ and lacking indication otherwise, in C as well. Some tables include a "In C" column that indicates whether an operator is also in C. Note that C does not support operator overloading.

When not overloaded, for the operators &&, ||, and , (the comma operator), there is a sequence point after the evaluation of the first operand.

Most of the operators available in C and C++ are also available in other C-family languages such as C#, D, Java, Perl, and PHP with the same precedence, associativity, and semantics.

Many operators specified by a sequence of symbols are commonly referred to by a name that consists of the name of each symbol. For example, += and -= are often called "plus equal(s)" and "minus equal(s)", instead of the more verbose "assignment by addition" and "assignment by subtraction".

Contents

• Operators

• Arithmetic

• Relational

• Logical

• Bitwise

• Assignment

• Member and pointer

• Other

• Synonyms

• Expression evaluation order

• Details

• Chained expressions

• Binding

• Criticism of bitwise and equality operators precedence

• Notes

• See also

• References

• External links

Operators

In the following tables, lower case letters such as a and b represent literal values, object/variable names, or l-values, as appropriate. R, S and T stand for a data type, and K for a class or enumeration type. Some operators have alternative spellings using digraphs and trigraphs or operator synonyms.

Arithmetic

C and C++ have the same arithmetic operators and all can be overloaded in C++.

|---|---|---|---|---|

Relational

All relational (comparison) operators can be overloaded in C++. Since C++20, the inequality operator is automatically generated if operator== is defined and all four relational operators are automatically generated if operator<=> is defined.cite-ref-3[1]

|---|---|---|---|---|---|

Logical

C and C++ have the same logical operators and all can be overloaded in C++.

Note that overloading logical AND and OR is discouraged, because as overloaded operators they always evaluate both operands instead of providing the normal semantics of short-circuit evaluation.cite-ref-6[2]

|---|---|---|---|---|

| NOT | NOT | ! a | bool K :: operator ! (); | bool operator ! ( K a ); |

| AND | AND | a && b | bool K :: operator && ( S b ); | bool operator && ( K a , S b ); |

| OR | OR | a // b | bool K :: operator // ( S b ); | bool operator // ( K a , S b ); |

Bitwise

C and C++ have the same bitwise operators and all can be overloaded in C++.

|---|---|---|---|---|

| NOT | NOT | ~ a | R K :: operator ~ (); | R operator ~ ( K a ); |

| AND | AND | a & b | R K :: operator & ( S b ); | R operator & ( K a , S b ); |

| OR | OR | a / b | R K :: operator / ( S b ); | R operator / ( K a , S b ); |

| XOR | XOR | a ^ b | R K :: operator ^ ( S b ); | R operator ^ ( K a , S b ); |

Assignment

C and C++ have the same assignment operators and all can be overloaded in C++.

For the combination operators, a ⊚= b (where ⊚ represents an operation) is equivalent to a = a ⊚ b, except that a is evaluated only once.

|---|---|---|---|

| Assignment | a = b | R & K :: operator = ( S b ); | — |

Member and pointer

|---|---|---|---|---|---|---|

| Subscript | Subscript | a [ b ] a <: b :> [ 4 ] | Yes | Yes | R & K :: operator []( S b ); R & K :: operator []( S b , ...); [ h ] | — |

| Indirection (object pointed to by a ) | Indirection (object pointed to by a ) | * a | Yes | Yes | R & K :: operator * (); | R & operator * ( K a ); |

| Structure dereference (member b of object pointed to by a ) | Structure dereference (member b of object pointed to by a ) | a -> b | Yes | Yes | R * K :: operator -> (); [ j ] | — |

| Structure reference (member b of object a ) | Structure reference (member b of object a ) | a . b | No | Yes | — | — |

| Member selected by pointer-to-member b of object pointed to by a [ k ] | Member selected by pointer-to-member b of object pointed to by a [ k ] | a ->* b | Yes | No | R & K :: operator ->* ( S b ); | R & operator ->* ( K a , S b ); |

| Member of object a selected by pointer-to-member b | Member of object a selected by pointer-to-member b | a .* b | No | No | — | — |

Other

|---|---|---|---|---|---|---|

| Function call | Function call | a ( a1, a2 ) | Yes | Yes | R K::operator ()( S a , T b , ...); | — |

| Comma | Comma | a , b | Yes | Yes | R K :: operator ,( S b ); | R operator ,( K a , S b ); |

| Ternary conditional | Ternary conditional | a ? b : c | No | Yes | — | — |

| Scope resolution | Scope resolution | a :: b [ l ] | No | No | — | — |

| User-defined literals [ m ] [ n ] | User-defined literals [ m ] [ n ] | "a"_b | Yes | No | — | R operator "" _b ( T a ) |

| Sizeof | Sizeof | sizeof a [ o ] sizeof (R) | No | Yes | — | — |

| Size of parameter pack [ n ] | Size of parameter pack [ n ] | sizeof... (Args) | No | No | — | — |

| Alignof [ n ] | Alignof [ n ] | alignof (R) or _Alignof (R) [ p ] | No | Yes | — | — |

| Decltype [ n ] | Decltype [ n ] | decltype (a) decltype (R) | No | No | — | — |

| Type identification | Type identification | typeid (a) typeid (R) | No | No | — | — |

| Conversion (C-style cast) | Conversion (C-style cast) | (R)a | Yes | Yes | K :: operator R (); [ 5 ] | — |

| Conversion [ q ] [ 6 ] | Conversion [ q ] [ 6 ] | R(a) R{a} [ n ] auto(a) [ h ] auto{a} [ h ] | No | No | — | — |

| static_cast conversion [ r ] | static_cast conversion [ r ] | static_cast <R>(a) | Yes | No | K :: operator R (); explicit K :: operator R (); [ n ] | — |

| dynamic cast conversion | dynamic cast conversion | dynamic_cast <R>(a) | No | No | — | — |

| const_cast conversion | const_cast conversion | const_cast <R>(a) | No | No | — | — |

| reinterpret_cast conversion | reinterpret_cast conversion | reinterpret_cast <R>(a) | No | No | — | — |

| Exception check [ n ] | Exception check [ n ] | noexcept (a) | No | No | — | — |

Synonyms

C++ defines keywords to act as aliases for a number of operators:cite-ref-committee-27-0[7]

| Keyword | Operator |

|---|---|

| and | && |

| and_eq | &= |

| bitand | & |

| bitor | / |

| compl | ~ |

| not | ! |

| not_eq | != |

| or | // |

| or_eq | /= |

| xor | ^ |

| xor_eq | ^= |

Each keyword is a different way to specify an operator and as such can be used instead of the corresponding symbolic variation. For example, (a > 0 and not flag) and (a > 0 && !flag) specify the same behavior. As another example, the bitand keyword may be used to replace not only the bitwise-and operator but also the address-of operator, and it can be used to specify reference types (e.g., int bitand ref = n).

The ISO C specification makes allowance for these keywords as preprocessor macros in the header file iso646.h. For compatibility with C, C++ also provides the header iso646.h, the inclusion of which has no effect. Until C++20, it also provided the corresponding header ciso646 which had no effect as well.

Expression evaluation order

During expression evaluation, the order in which sub-expressions are evaluated is determined by precedence and associativity. An operator with higher precedence is evaluated before a operator of lower precedence and the operands of an operator are evaluated based on associativity. The following table describes the precedence and associativity of the C and C++ operators. Operators are shown in groups of equal precedence with groups ordered in descending precedence from top to bottom (lower order is higher precedence).cite-ref-28[8]cite-ref-29[9]cite-ref-30[10]

Operator precedence is not affected by overloading.

|---|---|---|---|

| 2 | ++ | Postfix increment | Left-to-right |

| 2 | -- | Postfix decrement | Left-to-right |

| 2 | () | Function call | Left-to-right |

| 2 | [] | Array subscripting | Left-to-right |

| 2 | . | Element selection by reference | Left-to-right |

| 2 | -> | Element selection through pointer | Left-to-right |

| 3 | ++ | Prefix increment | Right-to-left |

| 3 | -- | Prefix decrement | Right-to-left |

| 3 | + | Unary plus | Right-to-left |

| 3 | - | Unary minus | Right-to-left |

| 3 | ! | Logical NOT | Right-to-left |

| 3 | ~ | Bitwise NOT ( ones' complement ) | Right-to-left |

| 3 | * | Indirection (dereference) | Right-to-left |

| 3 | & | Address-of | Right-to-left |

| 4 | .* | Pointer to member (C++ only) | Left-to-right |

| 4 | ->* | Pointer to member (C++ only) | Left-to-right |

| 5 | * | Multiplication | Left-to-right |

| 5 | / | Division | Left-to-right |

| 5 | % | Modulo (remainder) | Left-to-right |

| 6 | + | Addition | Left-to-right |

| 6 | - | Subtraction | Left-to-right |

| 7 | << | Bitwise left shift | Left-to-right |

| 7 | >> | Bitwise right shift | Left-to-right |

| 8 | <=> | Three-way comparison (Introduced in C++20 - C++ only) | Left-to-right |

| 9 | < | Less than | Left-to-right |

| 9 | <= | Less than or equal to | Left-to-right |

| 9 | > | Greater than | Left-to-right |

| 9 | >= | Greater than or equal to | Left-to-right |

| 10 | == | Equal to | Left-to-right |

| 10 | != | Not equal to | Left-to-right |

| 11 | & | Bitwise AND | Left-to-right |

| 12 | ^ | Bitwise XOR (exclusive or) | Left-to-right |

| 13 | / | Bitwise OR (inclusive or) | Left-to-right |

| 14 | && | Logical AND | Left-to-right |

| 15 | // | Logical OR | Left-to-right |

| 17 | ?: | Ternary conditional operator | Right-to-left |

| 17 | = | Direct assignment | Right-to-left |

| 17 | += | Assignment by sum | Right-to-left |

| 17 | -= | Assignment by difference | Right-to-left |

| 17 | *= | Assignment by product | Right-to-left |

| 17 | /= | Assignment by quotient | Right-to-left |

| 17 | %= | Assignment by remainder | Right-to-left |

| 17 | <<= | Assignment by bitwise left shift | Right-to-left |

| 17 | >>= | Assignment by bitwise right shift | Right-to-left |

| 17 | &= | Assignment by bitwise AND | Right-to-left |

| 17 | ^= | Assignment by bitwise XOR | Right-to-left |

| 17 | /= | Assignment by bitwise OR | Right-to-left |

Details

Although this table is adequate for describing most evaluation order, it does not describe a few details. The ternary operator allows any arbitrary expression as its middle operand, despite being listed as having higher precedence than the assignment and comma operators. Thus a ? b, c : d is interpreted as a ? (b, c) : d, and not as the meaningless (a ? b), (c : d). So, the expression in the middle of the conditional operator (between ? and :) is parsed as if parenthesized. Also, the immediate, un-parenthesized result of a C cast expression cannot be the operand of sizeof. Therefore, sizeof (int) * x is interpreted as (sizeof(int)) * x and not sizeof ((int) * x).

Chained expressions

The precedence table determines the order of binding in chained expressions, when it is not expressly specified by parentheses.

• For example, ++x*3 is ambiguous without some precedence rule(s). The precedence table tells us that: x is 'bound' more tightly to ++ than to *, so that whatever ++ does (now or later—see below), it does it ONLY to x (and not to x*3); it is equivalent to (++x, x*3).

• Similarly, with 3*x++, where though the post-fix ++ is designed to act AFTER the entire expression is evaluated, the precedence table makes it clear that ONLY x gets incremented (and NOT 3*x). In fact, the expression (tmp=x++, 3*tmp) is evaluated with tmp being a temporary value. It is functionally equivalent to something like (tmp=3*x, ++x, tmp).

• Abstracting the issue of precedence or binding, consider the diagram above for the expression 3+2*y[i]++. The compiler's job is to resolve the diagram into an expression, one in which several unary operators (call them 3+( . ), 2*( . ), ( . )++ and ( . )[ i ]) are competing to bind to y. The order of precedence table resolves the final sub-expression they each act upon: ( . )[ i ] acts only on y, ( . )++ acts only on y[i], 2*( . ) acts only on y[i]++ and 3+( . ) acts 'only' on 2*((y[i])++). It is important to note that WHAT sub-expression gets acted on by each operator is clear from the precedence table but WHEN each operator acts is not resolved by the precedence table; in this example, the ( . )++ operator acts only on y[i] by the precedence rules but binding levels alone do not indicate the timing of the postfix ++ (the ( . )++ operator acts only after y[i] is evaluated in the expression).

Binding

The binding of operators in C and C++ is specified by a factored language grammar, rather than a precedence table. This creates some subtle conflicts. For example, in C, the syntax for a conditional expression is:

logical-OR-expression ? expression : conditional-expression

while in C++ it is:

logical-OR-expression ? expression : assignment-expression

Hence, the expression:

e = a < d ? a++ : a = d

is parsed differently in the two languages. In C, this expression is a syntax error, because the syntax for an assignment expression in C is:

unary-expression '=' assignment-expression

In C++, it is parsed as:

e = (a < d ? a++ : (a = d))

which is a valid expression.cite-ref-31[11]cite-ref-32[12]

To use the comma operator in a function call argument expression, variable assignment, or a comma-separated list, use of parentheses is required.cite-ref-33[13]cite-ref-34[14] For example,

int a = 1, b = 2, weirdVariable = (++a, b), d = 4;

Criticism of bitwise and equality operators precedence

The precedence of the bitwise logical operators has been criticized.cite-ref-bell-35-0[15] Conceptually, & and | are arithmetic operators like * and +.

The expression a & b == 7 is syntactically parsed as a & (b == 7) whereas the expression a + b == 7 is parsed as (a + b) == 7. This requires parentheses to be used more often than they otherwise would.

Historically, there was no syntactic distinction between the bitwise and logical operators. In BCPL, B and early C, the operators && || didn't exist. Instead & | had different meaning depending on whether they are used in a 'truth-value context' (i.e. when a Boolean value was expected, for example in if (a==b & c) {...} it behaved as a logical operator, but in c = a & b it behaved as a bitwise one). It was retained so as to keep backward compatibility with existing installations.cite-ref-36[16]

Moreover, in C++ (and later versions of C) equality operations, with the exception of the three-way comparison operator, yield bool type values which are conceptually a single bit (1 or 0) and as such do not properly belong in "bitwise" operations.

Notes

cite-note-modulo-11. The modulus operator only supports integer operands; for floating point, a function such as fmod can be used.

cite-note-dummy-int-22. The int is a dummy parameter to differentiate between prefix and postfix.

cite-note-threewaycomparison-43. About C++20 three-way comparison

cite-note-54. Possible return types: std::weak_ordering, std::strong_ordering and std::partial_ordering to which they all are convertible to.

cite-note-bitshift-75. In the context of iostreams in C++, writers often will refer to << and >> as the "put-to" or "stream insertion" and "get-from" or "stream extraction" operators, respectively.

cite-note-96. According to the C99 standard, the right shift of a negative number is implementation defined. Most implementations, e.g., the GCC,cite-ref-integers-8-0[3] use an arithmetic shift (i.e., sign extension), but a logical shift is possible.

cite-note-rightbitshift-107. According to the C99 standard, the right shift of a negative number is implementation defined. Most implementations, e.g., the GCC,cite-ref-integers-8-1[3] use an arithmetic shift (i.e., sign extension), but a logical shift is possible.

cite-note-sincecxx23-128. since C++23

cite-note-addressof2-139. The actual address of an object with an overloaded operator & can be obtained with std::addressof

cite-note-arrowptr-1410. The return type of operator->() must be a type for which the -> operation can be applied, such as a pointer type. If x is of type C where C overloads operator->(), x->y gets expanded to x.operator->()->y.

cite-note-arrowstar-1511. citerefmeyers1999Meyers, Scott (October 1999), "Implementing operator->* for Smart Pointers" (PDF), Dr. Dobb's Journal, Aristeia.

cite-note-scopal-1612. Although a :: punctuator exists in C as of C23, it is not used as a scope resolution operator.

cite-note-ud-literal-1713. About C++11 User-defined literals

cite-note-sincecxx11-1814. since C++11

cite-note-sizeof-1915. The parentheses are not necessary when taking the size of a value, only when taking the size of a type. However, they are usually used regardless.

cite-note-alignof-2016. C++ defines alignof operator, whereas C defines _Alignof (C23 defines both). Both operators have the same semantics.

cite-note-2217. Behaves like const_cast/static_cast/reinterpret_cast. In the last two cases, the auto specifier is replaced with the type of the invented variable x declared with auto x(a); (which is never interpreted as a function declaration) or auto x{a};, respectively.

cite-note-2418. For user-defined conversions, the return type implicitly and necessarily matches the operator name unless the type is inferred (e.g. operator auto(), operator decltype(auto)() etc.).

cite-note-infer-2519. The type name can also be inferred (e.g new auto) if an initializer is provided.

cite-note-infer2-2620. The array size can also be inferred if an initializer is provided.